Apple WWDC 1996/WWDC96_1996 (CD).toast/Technology Materials/MacOS 8 Resources/Developer Tools/Mac OS 8 Interfaces & Libraries/Interfaces/CIncludes/MoviesFormat.h

C/C++ Source or Header | 1996-05-01 | 15KB | 607 lines

/*
     File:        MoviesFormat.h

     Contains:    QuickTime Interfaces.

     Version:    Technology:    QuickTime 2.1
                 Release:    Universal Interfaces 3.0d3 on Copland DR1

     Copyright:    © 1984-1996 by Apple Computer, Inc.  All rights reserved.

     Bugs?:        If you find a problem with this file, send the file and version
                 information (from above) and the problem description to:

                     Internet:    [e-mail]
                     AppleLink:    APPLE.BUGS

*/
#ifndef __MOVIESFORMAT__
#define __MOVIESFORMAT__

#ifndef __TYPES__
#include <Types.h>
#endif
#ifndef __WINDOWS__
#include <Windows.h>
#endif
#ifndef __IMAGECOMPRESSION__
#include <ImageCompression.h>
#endif
#ifndef __MOVIES__
#include <Movies.h>
#endif

#ifdef __cplusplus
extern "C" {
#endif

#if PRAGMA_IMPORT_SUPPORTED
#pragma import on
#endif

#if PRAGMA_ALIGN_SUPPORTED
#pragma options align=mac68k
#endif

#if FOR_SYSTEM7_AND_SYSTEM8_COOPERATIVE

enum {
    kMovieVersion                = 0                                /* version number of the format here described */
};

/*
***************************************
*
*   General Types -
*        These types are used in more than one of the
*        directory types.
*
***************************************
*/
/* MoviesUserData is the type used for user data in movie and track directories */
struct MoviesUserData {
    long                             size;                        /* size of this user data */
    long                             udType;                        /* type of user data */
    char                             data[1];                    /* the user data */
};
typedef struct MoviesUserData MoviesUserData;

struct UserDataAtom {
    long                             size;
    long                             atomType;
    MoviesUserData                     userData[1];
};
typedef struct UserDataAtom UserDataAtom;

/*
***************************************
*
*   MediaDirectory information -
*        The MediaDirectory is tightly coupled to the data.
*
***************************************
*/
struct SampleDescriptionAtom {
    long                             size;
    long                             atomType;                    /* = 'stsd' */
    long                             flags;                        /* 1 byte of version / 3 bytes of flags */
    long                             numEntries;
    SampleDescription                 sampleDescTable[1];
};
typedef struct SampleDescriptionAtom SampleDescriptionAtom;

/* TimeToSampleNum maps physical sample time to physical sample number. */
struct TimeToSampleNum {
    long                             sampleCount;
    TimeValue                         sampleDuration;
};
typedef struct TimeToSampleNum TimeToSampleNum;

struct TimeToSampleNumAtom {
    long                             size;
    long                             atomType;                    /* = 'stts' */
    long                             flags;                        /* 1 byte of version / 3 bytes of flags */
    long                             numEntries;
    TimeToSampleNum                 timeToSampleNumTable[1];
};
typedef struct TimeToSampleNumAtom TimeToSampleNumAtom;

/* SyncSamples is a list of the physical samples which are self contained. */
struct SyncSampleAtom {
    long                             size;
    long                             atomType;                    /* = 'stss' */
    long                             flags;                        /* 1 byte of version / 3 bytes of flags */
    long                             numEntries;
    long                             syncSampleTable[1];
};
typedef struct SyncSampleAtom SyncSampleAtom;

/* SampleToChunk maps physical sample number to chunk number. */
/* same as SampleToChunk, but redundant first sample is removed */
struct SampleToChunk {
    long                             firstChunk;
    long                             samplesPerChunk;
    long                             sampleDescriptionID;
};
typedef struct SampleToChunk SampleToChunk;

struct SampleToChunkAtom {
    long                             size;
    long                             atomType;                    /* = 'stsc' */
    long                             flags;                        /* 1 byte of version / 3 bytes of flags */
    long                             numEntries;
    SampleToChunk                     sampleToChunkTable[1];
};
typedef struct SampleToChunkAtom SampleToChunkAtom;

struct ChunkOffsetAtom {
    long                             size;
    long                             atomType;                    /* = 'stco' */
    long                             flags;                        /* 1 byte of version / 3 bytes of flags */
    long                             numEntries;
    long                             chunkOffsetTable[1];
};
typedef struct ChunkOffsetAtom ChunkOffsetAtom;

struct SampleSizeAtom {
    long                             size;
    long                             atomType;                    /* = 'stsz' */
    long                             flags;                        /* 1 byte of version / 3 bytes of flags */
    long                             sampleSize;
    long                             numEntries;
    long                             sampleSizeTable[1];
};
typedef struct SampleSizeAtom SampleSizeAtom;

struct ShadowSync {
    long                             fdSampleNum;
    long                             syncSampleNum;
};
typedef struct ShadowSync ShadowSync;

struct ShadowSyncAtom {
    long                             size;
    long                             atomType;                    /* = 'stsz' */
    long                             flags;                        /* 1 byte of version / 3 bytes of flags */
    long                             numEntries;
    ShadowSync                         shadowSyncTable[1];
};
typedef struct ShadowSyncAtom ShadowSyncAtom;

struct SampleTableAtom {
    long                             size;
    long                             atomType;                    /* = 'stbl' */

    SampleDescriptionAtom             sampleDescription;
    TimeToSampleNumAtom             timeToSampleNum;
    SampleToChunkAtom                 sampleToChunk;
    SyncSampleAtom                     syncSample;
    SampleSizeAtom                     sampleSize;
    ChunkOffsetAtom                 chunkOffset;
    ShadowSyncAtom                     shadowSync;
};
typedef struct SampleTableAtom SampleTableAtom;

struct PublicHandlerInfo {
    long                             flags;                        /* 1 byte of version / 3 bytes of flags */

    long                             componentType;
    long                             componentSubType;
    long                             componentManufacturer;
    long                             componentFlags;
    long                             componentFlagsMask;
    char                             componentName[1];
};
typedef struct PublicHandlerInfo PublicHandlerInfo;

struct HandlerAtom {
    long                             size;
    long                             atomType;                    /* = 'hdlr' */

    PublicHandlerInfo                 hInfo;
};
typedef struct HandlerAtom HandlerAtom;

/* a data reference is a private structure */
typedef long DataRefAtom;
struct DataInfoAtom {
    long                             size;
    long                             atomType;                    /* = 'dinf' */

    DataRefAtom                     dataRef;
};
typedef struct DataInfoAtom DataInfoAtom;

struct RgnAtom {
    long                             size;
    long                             atomType;

    short                             rgnSize;
    Rect                             rgnBBox;
    char                             data[1];
};
typedef struct RgnAtom RgnAtom;

struct MatteCompressedAtom {
    long                             size;
    long                             atomType;

    long                             flags;                        /* 1 byte of version / 3 bytes of flags */

    ImageDescription                 matteImageDescription;

    char                             matteData[1];
};
typedef struct MatteCompressedAtom MatteCompressedAtom;

struct MatteAtom {
    long                             size;
    long                             atomType;

    MatteCompressedAtom             aCompressedMatte;
};
typedef struct MatteAtom MatteAtom;

struct ClippingAtom {
    long                             size;
    long                             atomType;

    RgnAtom                         aRgnClip;
};
typedef struct ClippingAtom ClippingAtom;

/*
**********************
* Media Info Example Structures
**********************
*/
struct VideoMediaInfoHeader {
    long                             flags;                        /* 1 byte of version / 3 bytes of flags */

    short                             graphicsMode;                /* for QD - transfer mode */
    short                             opColorRed;                    /* opcolor for transfer mode */
    short                             opColorGreen;
    short                             opColorBlue;
};
typedef struct VideoMediaInfoHeader VideoMediaInfoHeader;

struct VideoMediaInfoHeaderAtom {
    long                             size;                        /* size of Media info */
    long                             atomType;                    /* = 'vmhd' */
    VideoMediaInfoHeader             vmiHeader;
};
typedef struct VideoMediaInfoHeaderAtom VideoMediaInfoHeaderAtom;

struct VideoMediaInfo {
    long                             size;                        /* size of Media info */
    long                             atomType;                    /* = 'minf' */

    VideoMediaInfoHeaderAtom         header;

    HandlerAtom                     dataHandler;

    DataInfoAtom                     dataInfo;

    SampleTableAtom                 sampleTable;
};
typedef struct VideoMediaInfo VideoMediaInfo;

struct SoundMediaInfoHeader {
    long                             flags;                        /* 1 byte of version / 3 bytes of flags */

    short                             balance;
    short                             rsrvd;
};
typedef struct SoundMediaInfoHeader SoundMediaInfoHeader;

struct SoundMediaInfoHeaderAtom {
    long                             size;                        /* size of Media info */
    long                             atomType;                    /* = 'vmhd' */

    SoundMediaInfoHeader             smiHeader;
};
typedef struct SoundMediaInfoHeaderAtom SoundMediaInfoHeaderAtom;

struct SoundMediaInfo {
    long                             size;                        /* size of Media info */
    long                             atomType;                    /* = 'minf' */

    SoundMediaInfoHeaderAtom         header;

    HandlerAtom                     dataHandler;

    DataRefAtom                     dataReference;

    SampleTableAtom                 sampleTable;
};
typedef struct SoundMediaInfo SoundMediaInfo;

/* whatever data the media handler needs goes after the atomType */
struct MediaInfo {
    long                             size;
    long                             atomType;
};
typedef struct MediaInfo MediaInfo;

/*
**********************
* Media Directory Structures
**********************
*/
struct MediaHeader {
    long                             flags;                        /* 1 byte of version / 3 bytes of flags */

    long                             creationTime;                /* seconds since Jan 1904 when directory was created */
    long                             modificationTime;            /* seconds since Jan 1904 when directory was appended */

    TimeValue                         timeScale;                    /* start time for Media (Media time) */
    TimeValue                         duration;                    /* length of Media (Media time) */

    short                             language;
    short                             quality;
};
typedef struct MediaHeader MediaHeader;

struct MediaHeaderAtom {
    long                             size;
    long                             atomType;

    MediaHeader                     header;
};
typedef struct MediaHeaderAtom MediaHeaderAtom;

struct MediaDirectory {
    long                             size;
    long                             atomType;                    /* = 'mdia' */

    MediaHeaderAtom                 mediaHeader;                /* standard Media information */

    HandlerAtom                     mediaHandler;

    MediaInfo                         mediaInfo;
};
typedef struct MediaDirectory MediaDirectory;

/*
**********************
* Track Structures
**********************
*/

enum {
    TrackEnable                    = 1 << 0,
    TrackInMovie                = 1 << 1,
    TrackInPreview                = 1 << 2,
    TrackInPoster                = 1 << 3
};

struct TrackHeader {
    long                             flags;                        /* 1 byte of version / 3 bytes of flags */

    long                             creationTime;                /* seconds since Jan 1904 when directory was created */
    long                             modificationTime;            /* seconds since Jan 1904 when directory was appended */

    long                             trackID;

    long                             reserved1;

    TimeValue                         duration;                    /* length of track (track time) */

    long                             reserved2;
    long                             reserved3;

    short                             layer;
    short                             alternateGroup;

    short                             volume;
    short                             reserved4;

    MatrixRecord                     matrix;
    Fixed                             trackWidth;
    Fixed                             trackHeight;
};
typedef struct TrackHeader TrackHeader;

struct TrackHeaderAtom {
    long                             size;                        /* size of track header */
    long                             atomType;                    /* = 'tkhd' */

    TrackHeader                     header;
};
typedef struct TrackHeaderAtom TrackHeaderAtom;

struct EditListType {
    TimeValue                         trackDuration;
    TimeValue                         mediaTime;
    Fixed                             mediaRate;
};
typedef struct EditListType EditListType;

struct EditListAtom {
    long                             size;
    long                             atomType;                    /* = elst */

    long                             flags;                        /* 1 byte of version / 3 bytes of flags */

    long                             numEntries;
    EditListType                     editListTable[1];
};
typedef struct EditListAtom EditListAtom;

struct EditsAtom {
    long                             size;
    long                             atomType;                    /* = edts */

    EditListAtom                     editList;
};
typedef struct EditsAtom EditsAtom;

struct TrackLoadSettings {
    TimeValue                         preloadStartTime;
    TimeValue                         preloadDuration;
    long                             preloadFlags;
    long                             defaultHints;
};
typedef struct TrackLoadSettings TrackLoadSettings;

struct TrackLoadSettingsAtom {
    long                             size;
    long                             atomType;                    /* = load */

    TrackLoadSettings                 settings;
};
typedef struct TrackLoadSettingsAtom TrackLoadSettingsAtom;

struct TrackDirectory {
    long                             size;
    long                             atomType;                    /* = 'trak' */

    TrackHeaderAtom                 trackHeader;                /* standard track information */

    ClippingAtom                     trackClip;

    EditsAtom                         edits;

    MediaDirectory                     media;

    UserDataAtom                     userData;                    /* space for extending with new data types */
};
typedef struct TrackDirectory TrackDirectory;

/*
***************************************
*
*   MovieDirectory -
*        The MovieDirectory is the top level structure which
*        holds the TrackInstance describing where the
*        TrackDirectories are.
*
***************************************
*/
struct MovieHeader {
    long                             flags;                        /* 1 byte of version / 3 bytes of flags */

    long                             creationTime;                /* seconds since Jan 1904 when directory was created */
    long                             modificationTime;            /* seconds since Jan 1904 when directory was appended */

    TimeValue                         timeScale;                    /* Time specifications */
    TimeValue                         duration;
    Fixed                             preferredRate;                /* rate at which to play this movie */

    short                             preferredVolume;            /* volume to play movie at */
    short                             reserved1;

    long                             preferredLong1;
    long                             preferredLong2;

    MatrixRecord                     matrix;

    TimeValue                         previewTime;                /* time in track the proxy begins (track time) */
    TimeValue                         previewDuration;            /* how long the proxy lasts (track time) */

    TimeValue                         posterTime;                    /* time in track the proxy begins (track time) */

    TimeValue                         selectionTime;                /* time in track the proxy begins (track time) */
    TimeValue                         selectionDuration;            /* time in track the proxy begins (track time) */
    TimeValue                         currentTime;                /* time in track the proxy begins (track time) */

    long                             nextTrackID;                /* next value to use for a TrackID */
};
typedef struct MovieHeader MovieHeader;

struct MovieHeaderAtom {
    long                             size;
    long                             atomType;                    /* = 'mvhd' */

    MovieHeader                     header;
};
typedef struct MovieHeaderAtom MovieHeaderAtom;

struct MovieDirectory {
    long                             size;
    long                             atomType;                    /* = 'moov' */

    MovieHeaderAtom                 header;

    ClippingAtom                     movieClip;

                                                                /* Track Directories */
    TrackDirectory                     track[1];

                                                                /* User data for Movie */
    UserDataAtom                     userData;                    /* space for user extensions */
};
typedef struct MovieDirectory MovieDirectory;

/*
***************************************
***************************************
*/
/* Movie formats and tags */

enum {
                                                                /* some system defined format IDs */
    MOVIE_TYPE                    = 'moov',
    TRACK_TYPE                    = 'trak',
    MEDIA_TYPE                    = 'mdia',
    VIDEO_TYPE                    = 'vide',
    SOUND_TYPE                    = 'soun'
};

/* atom id's */

enum {
    MovieAID                    = 'moov',
    MovieHeaderAID                = 'mvhd',
    ClipAID                        = 'clip',
    RgnClipAID                    = 'crgn',
    MatteAID                    = 'matt',
    MatteCompAID                = 'kmat',
    TrackAID                    = 'trak',
    UserDataAID                    = 'udta',
    TrackHeaderAID                = 'tkhd',
    EditsAID                    = 'edts',
    EditListAID                    = 'elst',
    MediaAID                    = 'mdia',
    MediaHeaderAID                = 'mdhd',
    MediaInfoAID                = 'minf',
    VideoMediaInfoHeaderAID        = 'vmhd',
    SoundMediaInfoHeaderAID        = 'smhd',
    GenericMediaInfoHeaderAID    = 'gmhd',
    GenericMediaInfoAID            = 'gmin',
    DataInfoAID                    = 'dinf',
    DataRefAID                    = 'dref',
    SampleTableAID                = 'stbl',
    STSampleDescAID                = 'stsd',
    STTimeToSampAID                = 'stts',
    STSyncSampleAID                = 'stss',
    STSampleToChunkAID            = 'stsc',
    STShadowSyncAID                = 'stsh',
    HandlerAID                    = 'hdlr',
    STSampleSizeAID                = 'stsz',
    STChunkOffsetAID            = 'stco',
    DataRefContainerAID            = 'drfc',
    TrackReferenceAID            = 'tref',
    ColorTableAID                = 'ctab',
    LoadSettingsAID                = 'load',
    PropertyAtomAID                = 'code',
    InputMapAID                    = 'imap'
};

#endif

#if PRAGMA_ALIGN_SUPPORTED
#pragma options align=reset
#endif

#if PRAGMA_IMPORT_SUPPORTED
#pragma import off
#endif

#ifdef __cplusplus
}
#endif

#endif /* __MOVIESFORMAT__ */